#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

const int basesize = 1024;
const int argvnum = 64; // 指令最多64个
const int envnum = 64;

// 全局的命令行参数
char *gargv[argvnum];
int gargc = 0;
int lastcode = 0;

// 我的系统的环境变量:需要自己维护默认从系统来
char *genv[envnum];
// 全局的当前shell的工作路径
char pwd[basesize];    // 当前路径
char pwdenv[basesize]; // 环境变量中的路径

// 4.执行命令
bool ExecuteCommand()
{
    // 让子进程执行
    pid_t id = fork();
    if (id < 0)
        return false;

    if (id == 0)
    {
        // 子进程
        // 1.执行命令
        execvpe(gargv[0], gargv, genv);
        // 2.退出
        exit(1);
    }

    int status = 0;
    pid_t rid = waitpid(id, &status, 0); // 子进程工作时，父进程阻塞等待子进程
    if (rid > 0)
    {
        if (WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100;
        }
        return true;
    }
    return false;
}

//添加环境变量
void AddEnv(const char *item)
{
    int index = 0;
    while(!genv[index])
    {
        index++;
    }
    genv[index] = (char*)malloc(strlen(item)+1);
    strncpy(genv[index],item,strlen(item)+1);
    genv[++index] = nullptr;

}

// 判断是否是内建命令并执行
bool CheckAndExecBuiltCommand()
{
    // printf("开始判断是不是内建命令\n");
    // shell的内建命令常用的数量是有限的，在此处使用枚举内建命令，依次处理
    if (strcmp(gargv[0], "cd") == 0)
    {
        if (gargc == 2)
        {
            // cd .. / cd ~
            chdir(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if (strcmp(gargv[0], "export") == 0) // 维护shell环境变量
    {
        // export导入环境变量也是内建命令
        if (gargc == 2)
        {
            AddEnv(gargv[1]); // 把变量导入到环境变量表中
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
        }
        return true;
    }
    else if (strcmp(gargv[0], "env") == 0)
    {
        for (int i = 0; genv[i]; i++)
        {
            printf("env[%d]: %s\n", i, genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if (strcmp(gargv[0], "echo") == 0)
    {
        if (gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if (gargv[1][0] == '$')
            {
                if (gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    // 每检查完一次，退出码清零
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    // printf("不是内建命令\n");
    return false;
}

// 测试
void dubug()
{
    printf("argc: %d\n", gargc);
    for (int i = 0; i < gargc; i++)
    {
        printf("argv[%d] : %s\n", i, gargv[i]);
    }
}

// 3.分析用户命令
// 将"ls -l -a -n"转换为"ls" "-l" "-a" "-n"
void ParseCommand(char command_buffer[], int len)
{
    (void)len;
    // 每次使用时全局数组要清空数据
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;

    //"ls -a -l -n"
    const char *sep = " ";
    // strtok首次使用传数组和分割变量，之后再使用，传空指针和分割字符串
    gargv[gargc++] = strtok(command_buffer, sep);
    // 分割成功返回字符串地址，失败返回nullptr，返回nullptr时while判断为false，跳出while循环
    while ((bool)(gargv[gargc++] = strtok(nullptr, sep)))
        ;
    gargc--; // 删掉最后返回的nullptr
}

// 2.获取用户命令
bool GetCommandLine(char command_buffer[], int size)
{
    // 我们将用户输入的命令行当做一个完整的字符串处理
    //"ls -a -l -n",此处不能用cin 或者scanf读取，遇到空格就停止读入
    char *result = fgets(command_buffer, size, stdin);
    if (!result)
        return false;

    command_buffer[strlen(command_buffer) - 1] = 0; // 即便什么都没有输入，按下空格长度至少为1，，处理空格导致的换行问题
    if (strlen(command_buffer) == 0)
        return false;
    return true;
}

// 获取用户名
string GetUserName()
{
    if (nullptr == getenv("USER"))
        return "None"; // 考虑返回值为空指针的情况

    string name = getenv("USER");
    return name.empty() ? "None" : name; // 考虑环境变量为空的情况
}

// 获取主机名
string GetHostName()
{
    return "VM-24-5-ubuntu";
    // if(nullptr == getenv("HOSTNAME")) return "None";//考虑返回值为空指针的情况

    // string hostname = getenv("HOSTNAME");
    // printf("%s\n",hostname);
    // return hostname.empty() ?"None" :hostname;
}

// 获取当前路径
string GetPwd()
{
    if (nullptr == getcwd(pwd, sizeof(pwd)))
        return "None";

    // 格式化输出
    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);

    putenv(pwdenv); // 修改自己的环境变量
    // 如果我们的环境变量时从系统中获取的，此时就会根据路径变化实时更新
    // 如果我们自己维护自己的环境变量，此时在路径发生改变的时候，就需要更新环境变量

    return pwd;

    // if(nullptr == getenv("PWD")) return "None";
    // string pwd = getenv("PWD");
    // return pwd.empty() ? "None" : pwd;
}

// 命令行提示符的路径，只取路径的最后一个部分
string GetLastDir()
{
    string curr = GetPwd();
    if (curr == "/" || curr == "None")
        return curr;

    // /home/zjiu/250731,只需要打印 250731
    size_t pos = curr.rfind("/");
    if (pos == std::string::npos)
        return curr;
    return curr.substr(pos + 1);
}

// 输出命令行格式
string MakeCommandLine()
{
    char command_line[basesize]; // 自定义缓冲区
    // 把指定字符串按照指定格式写入缓冲区
    snprintf(command_line, basesize, "[%s@%s %s]#",
             GetUserName().c_str(), GetHostName().c_str(), GetLastDir().c_str());

    return command_line;
}
// 1.命令行提示符，在环境变量中获取
void PrintCommandLine()
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}

// 作为shell获取环境变量应该从系统中配置
// 我们写的shell从父shell中获取环境变量
 void InitEnv()
 {
     extern char **environ;
     int index = 0;

     while(environ[index])
     {
         genv[index] = (char*)malloc(strlen(environ[index]+1));
         strncpy(genv[index],environ[index],strlen(environ[index])+1);
         index++;
     }
     genv[index] = nullptr;
 }

int main()
{

    InitEnv();//初始化环境变量

    char command_buffer[basesize];

    while (true)
    {
        PrintCommandLine(); // 1.命令行提示符

        if (!GetCommandLine(command_buffer, basesize)) // 2.获取用户命令
            continue;                                  // 如果没有，再次循环

        ParseCommand(command_buffer, basesize); // 3.分析命令，myshell形成一张命令表
        // dubug();
        // ExecuteCommand();
        // printf("已经生成argv表\n");

        if (CheckAndExecBuiltCommand()) // 4.执行内建命令
            continue;

        // printf("不是内建命令\n");
        ExecuteCommand(); // 4.执行命令，创建新的进程执行，如果直接让shell执行，如果程序出错，shell就挂了
    }

    return 0;
}